home *** CD-ROM | disk | FTP | other *** search
/ QRZ! Ham Radio 6 / QRZ Ham Radio Callsign Database - Volume 6.iso / mac / files / amiga / csrc720j.lzh / mbuser.c < prev    next >
C/C++ Source or Header  |  1993-01-18  |  17KB  |  832 lines
  1. /*
  2.  *  MBUSER.C - 6/28/92
  3.  */
  4.  
  5. #include "mb.h"
  6.  
  7. #define uf_inc 100    /* Headroom in user file */
  8.  
  9. #ifdef MCH_AMIGA
  10. extern short debug;
  11. extern char tmpstr[];
  12. #endif
  13.  
  14. char *usfile, *usbfile;
  15. USER_HDR *ufhs;
  16. USER     *tuser;
  17. char   *um[num_um];
  18. char   tcall[ln_call];
  19. short  maxusers;
  20. #ifndef MCH_AMIGA
  21. static char *users;
  22. #endif
  23.  
  24. #ifndef MCH_AMIGA
  25. int ufl;
  26. #else
  27. int ufl = -1;
  28. int uifl = -1;
  29. char *user_file = "T:mbuser.index";
  30. #endif
  31.  
  32. /*
  33.  *  Clean the user file.
  34.  *  Force drain of buffers, update of directory items.
  35.  */
  36.  
  37. clnuser()
  38. {
  39.   close(ufl);
  40.   ufl = open(usfile, O_RDWR | O_BINARY);
  41. #ifdef MCH_AMIGA
  42.    close(uifl);
  43.    uifl = open(user_file,O_RDWR | O_BINARY);
  44. #endif
  45. }
  46.  
  47. /*
  48.  *  Close the user file.
  49.  */
  50.  
  51. clsusr()
  52. {
  53. #ifdef MCH_AMIGA
  54.    if(ufl >= 0)
  55. #endif
  56.   close (ufl);
  57. #ifdef MCH_AMIGA
  58.    ufl = -1;
  59.    if(uifl >= 0)
  60.       close(uifl);
  61.    uifl = -1;
  62. #endif
  63. }
  64.  
  65. /*
  66.  *  Open the user file.
  67.  *  Allocate space for the user file records.
  68.  */
  69.  
  70. opnusr()
  71. {
  72.   ufhs = (USER_HDR *) malloc(sizeof(USER_HDR));
  73.  
  74.   tuser = (USER *) malloc(sizeof(USER));
  75.   tuser->rn = 0;
  76.  
  77. /*
  78.  *  Open the file. If it does not exist, make one.
  79.  */
  80. #ifdef MCH_AMIGA
  81.    lock_user();
  82. #endif
  83.  
  84.   ufl = open(usfile, O_RDWR | O_BINARY);
  85.   if (ufl < 0)
  86.   {
  87.     ufl = open(usfile, O_CREAT | O_RDWR | O_BINARY, pmode);
  88. #ifndef MCH_AMIGA
  89.     if (ufl < 0) { nofile(usfile); exit(1); }
  90. #else
  91.     if(ufl < 0) {
  92.        nofile(usfile);
  93. #ifdef MCH_AMIGA
  94.        unlock_user();
  95. #endif
  96.        done(1);
  97.     }
  98. #endif
  99.     inuhdr();
  100.     write_rec(ufl, 0, (char *)ufhs);
  101.   }
  102.  
  103. /*
  104.  *  Read the user calls.
  105.  */
  106.  
  107.   read_rec(ufl, 0, (char *)ufhs);
  108.  
  109.  
  110.   if (ufhs->version isnt us_version)
  111.   {
  112. #ifndef MCH_AMIGA
  113.     printf("Expected version %d, got version %d\n", us_version, ufhs->version);
  114. #else
  115.     sprintf(tmpstr,"Expected version %d, got version %d\n",
  116.                         us_version,ufhs->version);
  117.     ttputs(tmpstr);
  118. #endif
  119.     nofile(usfile);
  120. #ifndef MCH_AMIGA
  121.     exit(1);
  122. #else
  123.    set_user((long)ufhs->count);
  124.    unlock_user();
  125.    done(1);
  126. #endif
  127.   }
  128.  
  129.   maxusers = ufhs->count + uf_inc;
  130. #ifdef MCH_AMIGA
  131. /* size_t and numeric arg to errall*/
  132. #endif
  133. #ifndef MCH_AMIGA
  134.   users = (char *) malloc((size_t)ln_call * maxusers);
  135.   if (users is NULL) errall(2);
  136. #endif
  137.  
  138.   rdusers();
  139. #ifdef MCH_AMIGA
  140.    unlock_user();
  141. #endif
  142. }
  143.  
  144. /*
  145.  *  Open the user file and read record zero
  146.  */
  147.  
  148. readusr()
  149. {
  150. #ifndef MCH_AMIGA
  151.   short prev_cnt;
  152.  
  153.   prev_cnt = ufhs->count;
  154.   ufl = open(usfile, O_RDWR | O_BINARY);
  155.   read_rec (ufl, 0, (char*)ufhs);
  156.   if (ufhs->count isnt prev_cnt) rdusers();
  157. #else
  158.    lock_user();
  159.    ufl = open(usfile, O_RDWR | O_BINARY);
  160.    read_rec (ufl, 0, (char*)ufhs);
  161.    rdusers();
  162.    unlock_user();
  163. #endif
  164. }
  165.  
  166. /*
  167.  *  Read each user record, build list of calls.
  168.  */
  169. #ifdef MCH_AMIGA
  170. char first_time = 1;
  171. #endif
  172. rdusers()
  173. {
  174.   register int i;
  175.   register char *up;
  176.  
  177. #ifndef MCH_AMIGA
  178.   printf("%d users in %s\n", ufhs->count, usfile);
  179.   for (i = 1, up = users; i <= ufhs->count; i++, up += ln_call)
  180.   {
  181.     read_rec(ufl, i, (char *)tuser);
  182.     strncpy(up, tuser->call, ln_call);
  183.   }
  184. #else
  185.    if(first_time) {
  186.       first_time = 0;
  187.       sprintf(tmpstr,"%d users in %s\n", ufhs->count, usfile);
  188.       ttputs(tmpstr);
  189.    }
  190.    /* If the index file exists, then just open it
  191.       otherwise create it from the user.dat file
  192.    */
  193.    if((uifl = open(user_file,O_RDWR | O_BINARY)) >= 0)return;
  194.    uifl = open(user_file,O_RDWR | O_BINARY | O_CREAT);
  195.    for(i = 1; i <= ufhs->count; i++) {
  196.       read_rec(ufl, i, (char *)tuser);
  197.       write(uifl, tuser->call,ln_call);
  198.    }
  199. #endif
  200.  
  201. }
  202.  
  203. /*
  204.  *  initialize the user file header.
  205.  */
  206.  
  207. inuhdr()
  208. {
  209.   curtim();
  210.   ufhs->count = 0;
  211.   ufhs->version = us_version;
  212.   strncpy(ufhs->date, l_date, ln_date);
  213.   strncpy(ufhs->time, l_time, ln_time);
  214.   ufhs->lmnr = mfhs->next_msg - 1;
  215.   fill (ufhs->unu, '\0', ufhsunu);
  216. }
  217.  
  218. /*
  219.  *  Do we know this user?
  220.  */
  221.  
  222. finduser(call)
  223. char *call;
  224. {
  225.   register int i;
  226.   register char *up;
  227.  
  228. #ifndef MCH_AMIGA
  229.   for (i = 1, up = users; i <= ufhs->count; i++, up += ln_call)
  230.   if (matchn(call, up, ln_call)) return i;
  231. #else
  232.    check_user();
  233.    unlock_user();
  234.    lseek(uifl,0L,0);
  235.    for(i = 1; i <= ufhs->count; i++) {
  236.       read(uifl,tmpstr,(size_t)ln_call);
  237.       if(matchn(call, tmpstr, ln_call)) return i;
  238.    }
  239. #endif
  240.   return 0;
  241. }
  242.  
  243. /*
  244.  *  Read in a user record.
  245.  */
  246.  
  247. rduser(call, buf)
  248. char *call;
  249. USER *buf;
  250. {
  251.   register int i;
  252.  
  253.   if (i = finduser(call))
  254.   {
  255.     read_rec(ufl, i, (char *)buf);
  256.     buf->rn = i;
  257.     return i;
  258.   }
  259.  
  260. /*
  261.  *  There wasn't one, make one.
  262.  */
  263.  
  264.   curtim();
  265.  
  266.   buf->rn = 0;  /* Mark as non current record */
  267.  
  268.   strncpy(buf->call, call,   ln_call);
  269.   strncpy(buf->date, l_date, ln_date);
  270.   strncpy(buf->time, l_time, ln_time);
  271.  
  272.   buf->msg_number = 0;
  273.   buf->ssid       = 0;
  274.   buf->state      = 0;
  275.   buf->options    = 0;
  276.   buf->log_count  = 0;
  277.   buf->port       = ' ';
  278.  
  279.   ljsf(buf->handle, um[0], ln_handle);
  280.  
  281.   fill(buf->path, ' ', pathl);
  282.   *buf->path = '\0';
  283.  
  284.   fill(buf->home_bbs, ' ', ln_call);
  285.   fill(buf->zip,      ' ', ln_zip);
  286. #ifdef MCH_AMIGA
  287.   fill(buf->qth,      ' ',ln_qth);
  288. #endif
  289.   fill(buf->unu,        0, userunu);
  290.  
  291.   return 0;
  292. }
  293.  
  294. /*
  295.  *  Update the user record to the file.
  296.  */
  297.  
  298. upduser(buf)
  299. USER *buf;
  300. {
  301. #ifdef MCH_AMIGA
  302.    check_user();
  303. #endif
  304.   if (s_flag & s_dv) begin_lock();
  305.   read_rec(ufl, 0, (char*)ufhs);
  306.   if (!buf->rn)
  307.   {
  308. #ifndef MCH_AMIGA
  309.     if (ufhs->count >= maxusers)
  310.       {
  311.    if (s_flag & s_dv) end_lock();
  312.    return;
  313.       }
  314.     strncpy (users + (ln_call * ufhs->count), buf->call, ln_call);
  315. #endif
  316.     buf->rn = ++ufhs->count;
  317. #ifdef MCH_AMIGA
  318.       lseek(uifl,0L,2);
  319.       write(uifl,buf->call,ln_call);
  320.       set_user((long)buf->rn);
  321. #endif
  322.   }
  323.  
  324.   curtim();
  325.   strncpy(buf->date, l_date, ln_date);
  326.   strncpy(buf->time, l_time, ln_time);
  327.   if (s_flag & s_update)
  328.     {
  329.       buf->msg_number = mfhs->next_msg;
  330.       s_flag clrbit s_update;
  331.     }
  332.   buf->log_count++;
  333.   write_rec(ufl, buf->rn, (char *)buf);
  334.   write_rec(ufl, 0, (char *)ufhs);
  335.   if (s_flag & s_dv) end_lock();
  336. #ifdef MCH_AMIGA
  337.    unlock_user();
  338. #endif
  339. }
  340.  
  341. /*
  342.  *  Print the address of BBS in STATES.MB
  343.  */
  344.  
  345. pstates()
  346. {
  347.   FILE *hier;
  348.   char hiercall[ln_call];
  349.  
  350.   port->msg = mfind;
  351.   if ((hier = fopen( stfile, "r")) is NULL) return;
  352.   while (fgets(tmp->scr, linelen, hier) isnt NULL)
  353.     {
  354.       pcall(hiercall, tmp->scr);
  355.       if (wcm(hiercall, tcall))
  356.    {
  357.      outstr("BBS Address -> ");
  358.      outstr(tmp->scr);
  359.      outchar('\n');
  360.      port->msg = NULL;
  361.      break;
  362.    }
  363.     }
  364.   fclose(hier);
  365.   return;
  366. }
  367.  
  368. /*
  369.  *  Print info about a user.
  370.  */
  371.  
  372. puser()
  373. {
  374.   register int i;
  375.   register PORTS *p;
  376.  
  377.   pcall(tcall, port->fld[1]);
  378.   if (!(i = finduser(tcall))) { pstates(); return; }
  379.  
  380.   read_rec(ufl, i, (char *)tuser);
  381.  
  382.   if ((p = findport(tuser->port)) is NULL)
  383.     sprintf( tmp->scr, "Port %c\n", tuser->port);
  384.   else
  385.     sprintf(tmp->scr, "%s\n", p->name);
  386.   if(tuser->port isnt 'Z')
  387.   {
  388.     outnb(tuser->call, ln_call);
  389.     outstr(" connected on ");
  390.     outstr(tmp->scr);
  391.   }
  392.   outnb(tuser->call, ln_call);
  393.   if (tuser->port is 'Z')
  394.   {
  395.     outstr(" Linked to "); outnb(cport->user->call, ln_call);
  396.     outstr(" Through the GateWay at "); outstr(tuser->path);
  397.   }
  398.   else if (!*tuser->path)
  399.   {
  400.     outstr(" is a direct connect from "); outnb(cport->user->call, ln_call);
  401.   }
  402.   else
  403.   {
  404.     outstr(" connected to "); outnb(cport->user->call, ln_call);
  405.     outstr(" via "); outstr(tuser->path);
  406.   }
  407.   outchar('\n');
  408.  
  409.   outnb(tuser->call, ln_call);
  410.   sprintf(tmp->scr, " Last connected on %6.6s at %4.4s\n",
  411.     tuser->date, tuser->time);
  412.   outstr(tmp->scr);
  413.  
  414.   outstr("Name - ");
  415.   outnb(tuser->handle, ln_handle);
  416.  
  417.   if (tuser->state & u_home)
  418.   {
  419.     outstr(", Mail bbs - ");
  420.     outnb(tuser->home_bbs, ln_call);
  421.   }
  422.  
  423.   if (tuser->state & u_qth)
  424.   {
  425.     sprintf(tmp->scr, ", QTH - %s", tuser->qth);
  426.     outstr(tmp->scr);
  427.   }
  428.  
  429.   if (tuser->state & u_zip)
  430.   {
  431.     outstr(", Zip - ");
  432.     outnb(tuser->zip, ln_zip);
  433.   }
  434.     outchar('\n');
  435. }
  436.  
  437. /*
  438.  *  Print a user record.
  439.  */
  440.  
  441. prtuser(p)
  442. USER *p;
  443. {
  444.   fill(port->cmd, ' ', 7);
  445.   if (p->options & u_local)   port->cmd[0] = 'L';
  446.   if (p->options & u_bbs)     port->cmd[1] = 'B';
  447.   if (p->options & u_expert)  port->cmd[2] = 'E';
  448.   if (p->options & u_delete)  port->cmd[3] = 'D';
  449.   if (p->options & u_sysop)   port->cmd[4] = 'S';
  450.   if (p->options & u_exclude) port->cmd[5] = 'X';
  451.   if (p->options & u_hold)    port->cmd[6] = 'H';
  452.   sprintf(tmp->scr,
  453.   "%6.6s %6.6s %4.4s %4d %5u %6.6s %2.2d%c%7.7s %-12.12s %6.6s\n%-20.20sPath: %s\n",
  454.     p->call, p->date, p->time, p->log_count,
  455.     p->msg_number, p->home_bbs, p->ssid,
  456.     p->port, port->cmd, p->handle, p->zip, p->qth, p->path);
  457.  
  458.   outstr(tmp->scr);
  459. }
  460.  
  461. /*
  462.  *  The "display users" command.
  463.  */
  464.  
  465. duser()
  466. {
  467.   register int i;
  468.   register short ok;
  469.  
  470.   if (port->flds is 1) pgst(um[2]); else
  471.   {
  472.     if ((port->fl = fopen(port->fld[1], "r")) isnt NULL)
  473.     { fclose(port->fl); port->msg = mexst; return; }
  474.     if ((port->fl = fopen(port->fld[1], "w")) is NULL)
  475.     { port->msg = mcant; return; }
  476.   }
  477. #ifdef MCH_AMIGA
  478.    check_user();
  479.    unlock_user();
  480. #endif
  481.  
  482.   for (i = ufhs->count; i; i--)
  483.   {
  484.     read_rec(ufl, i, (char *)tuser);
  485.     ok = false;
  486.     switch(port->opt2)
  487.     {
  488.       case 'L' : ok = (tuser->options & u_local);  break;
  489.       case 'M' : ok = (tuser->options & u_bbs);    break;
  490.       case 'S' : ok = (tuser->options & u_sysop);  break;
  491.       case 'U' : ok = true; break;
  492.       case 'X' : ok = (tuser->options & u_exclude); break;
  493.     }
  494.  
  495.     if (ok)
  496.     {
  497.       if (port->flds is 1)
  498.       {
  499.    pghd();
  500.    prtuser(tuser);
  501.    if (pgck() is 'Q') return;
  502.    if (pgck() is 'Q') return;
  503.       }
  504.       else
  505.       {
  506.    prtuser(tuser);
  507.    fprintf(port->fl, "%s", tmp->scr);
  508.       }
  509.     }
  510.   }
  511.   if (port->flds is 1) pgdn(); else fclose(port->fl);
  512. }
  513.  
  514. /*
  515.  *  The N, NE, NH, NQ, NZ (update my user info) commands.
  516.  */
  517.  
  518. chguser()
  519. {
  520.   port->msg = mdone;
  521.   switch(port->opt2)
  522.   {
  523.     case ' ' : ljsf(port->user->handle, port->line + 2, ln_handle);
  524.           port->user->state setbit u_name;
  525.           break;
  526.  
  527.     case 'E' : port->user->options flipbit u_expert;
  528.           break;
  529.  
  530.     case 'H' : if (!iscall(port->fld[1]))
  531.           {
  532.        port->msg = mwhat;
  533.        break;
  534.           }
  535.       if (matchn(port->user->call, port->fld[1], strlen(port->fld[1])))
  536.           {
  537.        port->msg = um[8];
  538.        break;
  539.           }
  540.           pcall(port->user->home_bbs, port->fld[1]);
  541.  
  542.           if (matchn(port->user->home_bbs, cport->user->call, ln_call))
  543.        port->user->options setbit u_local;
  544.           else port->user->options clrbit u_local;
  545.  
  546.           port->user->state setbit u_home;
  547.           port->user->state clrbit u_sent;
  548.           break;
  549.  
  550.     case 'P' : port->user->state flipbit u_pause;
  551.           if (port->user->state & u_pause) outstr("pause off ");
  552. #ifndef MCH_AMIGA
  553.           else outstr("on ");
  554. #else
  555.           else outstr("pause on ");
  556. #endif
  557.           break;
  558.  
  559.     case 'Q' : remnl(port->line);
  560.           strncpy(port->user->qth, port->line+3, ln_qth);
  561.           port->user->state setbit u_qth;
  562.           break;
  563.  
  564.     case 'Z' : ljsf(port->user->zip, port->fld[1], ln_zip);
  565.           port->user->state setbit u_zip;
  566.           port->user->state clrbit u_sent;
  567.           break;
  568.   }
  569. }
  570.  
  571. /*
  572.  *  EU command with no argument.
  573.  *  Loop through all users, ask delete for each one.
  574.  */
  575.  
  576. edusera()
  577. {
  578.   register word i;
  579. #ifdef MCH_AMIGA
  580.    check_user();
  581.    unlock_user();
  582. #endif
  583.   for (i = ufhs->count; i; i--)
  584.   {
  585.     read_rec(ufl, i, (char *)tuser);
  586.     if (tuser->rn isnt i)
  587.     {
  588.       sprintf(tmp->scr, "User record %u has record # %u\n", i, tuser->rn);
  589.       tuser->rn = i;
  590.     }
  591.  
  592.     prtx(um[2]);
  593.     prtuser(tuser);
  594.  
  595.     prtx(um[3]); getcmd();
  596.     if (port->mode & gone) return;
  597.     if (port->opt1 is 'Q') return;
  598.     if (port->opt1 is 'Y')
  599.     {
  600.       tuser->options |= u_delete;
  601.       write_rec(ufl, tuser->rn, (char *)tuser);
  602.     }
  603.   }
  604. }
  605.  
  606. /*
  607.  *  Edit a user record.
  608.  */
  609.  
  610. eduser()
  611. {
  612.   register USER *u;
  613.  
  614.   pcall(tcall, port->fld[1]);
  615.   if (matchn(tcall, port->user->call, ln_call)) u = port->user;
  616.   else { u = tuser; rduser(tcall, u); }
  617.   while(*port->fld[0] isnt '\0')
  618.   {
  619.     prtuser(u);
  620.     outstr("PRIVILEGE: (D)elete (E)xpert (B)bs (S)ysop e(X)clude h(O)ld\n");
  621.     outstr("DATA: (C)all ss(I)d (N)ame por(T) (P)ath (H)ome (Q)th (Z)ip\n");
  622.     getcmd();
  623.     if (port->mode & gone) return;
  624.     switch(*port->fld[0])
  625.     {
  626.       case 'D' : u->options flipbit u_delete; *port->fld[0] = '\0'; break;
  627.       case 'E' : u->options flipbit u_expert; break;
  628.       case 'B' : u->options flipbit u_bbs; break;
  629.       case 'O' : u->options flipbit u_hold; break;
  630.       case 'S' : u->options flipbit u_sysop; break;
  631.       case 'X' : u->options flipbit u_exclude;break;
  632.       case 'C' : if (*port->fld[1]) pcall(u->call, port->fld[1]); break;
  633.       case 'I' : u->ssid = atoi(port->fld[1]); break;
  634.       case 'N' : if (*port->fld[1])
  635.        {
  636.          u->state setbit u_name;
  637.          ljsf(u->handle, port->line+2, ln_handle);
  638.        }
  639.        break;
  640.       case 'T' : if (*port->fld[1]) u->port = *port->fld[1]; break;
  641.       case 'P' : if (port->fld[1]) strncpy(u->path, port->fld[1], pathl);
  642.        else *u->path = '\0'; break;
  643.       case 'H' : if (*port->fld[1])
  644.        {
  645.          u->state setbit u_home;
  646.          u->state clrbit u_sent;
  647.          pcall(u->home_bbs, port->fld[1]);
  648.          if (matchn(u->home_bbs, cport->user->call, ln_call))
  649.          u->options setbit u_local; else u->options clrbit u_local;
  650.        }
  651.        else
  652.        {
  653.          fill(u->home_bbs, ' ', ln_call);
  654.          u->options clrbit u_local;
  655.          u->state clrbit u_home;
  656.          u->state setbit u_sent;
  657.        }
  658.        break;
  659.       case 'Q' : if (*port->fld[1])
  660.        {
  661.          u->state setbit u_qth;
  662.          remnl(port->line);
  663.          strncpy(u->qth, port->line+2, ln_qth);
  664.        }
  665.        else
  666.        {
  667.          fill(u->qth, '\0', ln_qth);
  668.          u->state clrbit u_qth;
  669.        }
  670.        break;
  671.       case 'Z' : if (*port->fld[1])
  672.        {
  673.          u->state setbit u_zip;
  674.          u->state clrbit u_sent;
  675.          ljsf(u->zip, port->fld[1], ln_zip);
  676.        }
  677.        else
  678.        {
  679.          fill(u->zip, ' ', ln_zip);
  680.          u->state clrbit u_zip;
  681.          u->state setbit u_sent;
  682.        }
  683.        break;
  684.     }
  685.   }
  686.  
  687. /*
  688.  *  If this is a new user, add to the list.
  689.  */
  690.  
  691.   upduser(u);
  692. }
  693.  
  694. /*
  695.  *  Backup the user file.
  696.  */
  697.  
  698. untuser()
  699. {
  700.   register char *rp, *wp, *lp;
  701.   register int uflb;
  702.   register int incnt, inrec;
  703.  
  704.   if (sure()) return;
  705.   prtx(um[1]);
  706.   lp = tmp->scr + (RECSIZE * (scrmax / RECSIZE));
  707.   upduser(port->user);
  708.   close(ufl);
  709.   unlink(usbfile);
  710.  
  711.   if (samedir(usfile, usbfile)) rename(usfile, usbfile);
  712.   else copy(usfile, usbfile, false);
  713.  
  714.   unlink(usfile);
  715.  
  716.   ufl  = open(usfile,  O_CREAT  | O_RDWR | O_BINARY, pmode);
  717.   uflb = open(usbfile, O_RDONLY | O_BINARY);
  718.  
  719.   incnt = ufhs->count;
  720.   inuhdr();
  721.  
  722.   inrec = 1;
  723.   while(incnt)
  724.   {
  725.     for (rp = tmp->scr; (rp < lp) and incnt;)
  726.     {
  727.       incnt--;
  728.       read_rec(uflb, inrec++, rp);
  729.       if (!(((USER *)rp)->options & u_delete)) rp += RECSIZE;
  730.     }
  731.     for (wp = tmp->scr; wp < rp; wp += RECSIZE)
  732.       write_rec(ufl, ++ufhs->count, wp);
  733.   }
  734.  
  735.   write_rec(ufl, 0, (char *)ufhs);
  736.   close (uflb);
  737.   clnuser();
  738. #ifdef MCH_AMIGA
  739. /* clobber the index file
  740.    rdusers will recreate it and leave it open
  741. */
  742.    close(uifl);
  743.    unlink(user_file);
  744. #endif
  745.   rdusers();
  746.   rduser(port->user->call, port->user);
  747. }
  748.  
  749. /*
  750.  *  If all ports are free, Issue the command for all ports to lockup.
  751.  *  wait for confirmation and then do the command.
  752.  */
  753.  
  754. setunt()
  755. {
  756.   word pflg;
  757.   long l;
  758.  
  759. #ifndef MCH_AMIGA
  760.   if (!(s_flag & s_dv))
  761.   {
  762.     do_op();
  763.     return;
  764.   }
  765.  
  766. /*
  767.  *  If all windows are free issue the lock command
  768.  */
  769.  
  770.   getbusy();
  771.   if (b_flag is p_window)
  772.   {
  773.     putcomd ('A', 'H');
  774.     pflg = getp_flag();
  775.     putc_flag (pflg clrbit p_window);
  776.   }
  777.   else
  778.   {
  779.     outstr("Other windows BUSY\n");
  780.     return;
  781.   }
  782.  
  783. /*
  784.  *  Wait for windows to confirm the lock by looking for a
  785.  *  cleared c_flag. Do the command if cleared, otherwise return.
  786.  */
  787.  
  788.   settmr( &l, 20);
  789.   while (true)
  790.   {
  791.     if (!(chktmr(l)))
  792.     {
  793.       putc_flag(0); break;
  794.     }
  795.     getc_flag();
  796.     if (c_flag  is 0)
  797.     {
  798.       do_op();
  799.       break;
  800.     }
  801.     switchw();
  802.   }
  803.   putcomd('\0','\0');
  804. #else
  805.    if(getbusy()) {
  806.       outstr("Other windows BUSY\n");
  807.       return;
  808.    }
  809.    do_op();
  810.    unbusy();
  811. #endif
  812. }
  813. do_op()
  814. {
  815.   switch(port->opt2)
  816.   {
  817.     case 'A' :
  818.     case 'R' :
  819.     case 'M' : if (untmsg()) cprs_bid(); break;
  820.     case 'U' : untuser(); break;
  821.     default  : ;
  822.   }
  823. }
  824. #ifdef MCH_AMIGA
  825. check_user()
  826. {
  827.    extern long get_user();
  828.    lock_user();
  829.    if(ufhs->count != get_user())clnuser();
  830. }
  831. #endif
  832.